home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / pdftops / goo / c / gmem < prev    next >
Text File  |  1996-05-23  |  3KB  |  180 lines
  1. /*
  2.  * gmem.c
  3.  *
  4.  * Memory routines with out-of-memory checking.
  5.  *
  6.  * Copyright 1996 Derek B. Noonburg
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <stddef.h>
  12. #include <string.h>
  13. #include <gmem.h>
  14.  
  15. #ifdef DEBUG_MEM
  16. typedef struct _GMemHdr {
  17.   int size;
  18.   int index;
  19.   struct _GMemHdr *next;
  20. } GMemHdr;
  21.  
  22. #define gMemHdrSize ((sizeof(GMemHdr) + 7) & ~7)
  23. #define gMemTrlSize (sizeof(long))
  24.  
  25. #if gmemTrlSize==8
  26. #define gMemDeadVal 0xdeadbeefdeadbeef
  27. #else
  28. #define gMemDeadVal 0xdeadbeef
  29.  
  30. /* round data size so trailer will be aligned */
  31. #define gMemDataSize(size) \
  32.   ((((size) + gMemTrlSize - 1) / gMemTrlSize) * gMemTrlSize)
  33.  
  34. #endif
  35.  
  36. static GMemHdr *gMemList = NULL;
  37. static int gMemIndex = 0;
  38. static int gMemAlloc = 0;
  39. #endif
  40.  
  41. void *gmalloc(int size) {
  42. #if DEBUG_MEM
  43.   int size1;
  44.   char *mem;
  45.   GMemHdr *hdr;
  46.   void *data;
  47.   long *trl;
  48.  
  49.   if (size == 0)
  50.     return NULL;
  51.   size1 = gMemDataSize(size);
  52.   if (!(mem = (char *)malloc(size1 + gMemHdrSize + gMemTrlSize))) {
  53.     fprintf(stderr, "Out of memory\n");
  54.     exit(1);
  55.   }
  56.   hdr = (GMemHdr *)mem;
  57.   data = (void *)(mem + gMemHdrSize);
  58.   trl = (long *)(mem + gMemHdrSize + size1);
  59.   hdr->size = size;
  60.   hdr->index = gMemIndex++;
  61.   hdr->next = gMemList;
  62.   gMemList = hdr;
  63.   ++gMemAlloc;
  64.   *trl = gMemDeadVal;
  65.   return data;
  66. #else
  67.   void *p;
  68.  
  69.   if (size == 0)
  70.     return NULL;
  71.   if (!(p = malloc(size))) {
  72.     fprintf(stderr, "Out of memory\n");
  73.     exit(1);
  74.   }
  75.   return p;
  76. #endif
  77. }
  78.  
  79. void *grealloc(void *p, int size) {
  80. #if DEBUG_MEM
  81.   GMemHdr *hdr;
  82.   void *q;
  83.   int oldSize;
  84.  
  85.   if (size == 0) {
  86.     if (p)
  87.       gfree(p);
  88.     return NULL;
  89.   }
  90.   if (p) {
  91.     hdr = (GMemHdr *)((char *)p - gMemHdrSize);
  92.     oldSize = hdr->size;
  93.     q = gmalloc(size);
  94.     memcpy(q, p, size < oldSize ? size : oldSize);
  95.     gfree(p);
  96.   } else {
  97.     q = gmalloc(size);
  98.   }
  99.   return q;
  100. #else
  101.   void *q;
  102.  
  103.   if (size == 0) {
  104.     if (p)
  105.       free(p);
  106.     return NULL;
  107.   }
  108.   if (p)
  109.     q = realloc(p, size);
  110.   else
  111.     q = malloc(size);
  112.   if (!q) {
  113.     fprintf(stderr, "Out of memory\n");
  114.     exit(1);
  115.   }
  116.   return q;
  117. #endif
  118. }
  119.  
  120. void gfree(void *p) {
  121. #ifdef DEBUG_MEM
  122.   int size;
  123.   GMemHdr *hdr;
  124.   GMemHdr *prevHdr, *q;
  125.   long *trl;
  126.  
  127.   if (p) {
  128.     hdr = (GMemHdr *)((char *)p - gMemHdrSize);
  129.     for (prevHdr = NULL, q = gMemList; q; prevHdr = q, q = q->next) {
  130.       if (q == hdr)
  131.     break;
  132.     }
  133.     if (q) {
  134.       if (prevHdr)
  135.     prevHdr->next = hdr->next;
  136.       else
  137.     gMemList = hdr->next;
  138.       --gMemAlloc;
  139.       size = gMemDataSize(hdr->size);
  140.       trl = (long *)((char *)hdr + gMemHdrSize + size);
  141.       if (*trl != gMemDeadVal) {
  142.     fprintf(stderr, "Overwrite past end of block %d at address %p\n",
  143.         hdr->index, p);
  144.       }
  145.       free(hdr);
  146.     } else {
  147.       fprintf(stderr, "Attempted to free bad address %p\n", p);
  148.     }
  149.   }
  150. #else
  151.   if (p)
  152.     free(p);
  153. #endif
  154. }
  155.  
  156. #ifdef DEBUG_MEM
  157. void gMemReport(FILE *f) {
  158.   GMemHdr *p;
  159.  
  160.   fprintf(f, "%d memory allocations in all\n", gMemIndex);
  161.   if (gMemAlloc > 0) {
  162.     fprintf(f, "%d memory blocks left allocated:\n", gMemAlloc);
  163.     fprintf(f, " index     size\n");
  164.     fprintf(f, "-------- --------\n");
  165.     for (p = gMemList; p; p = p->next)
  166.       fprintf(f, "%8d %8d\n", p->index, p->size);
  167.   } else {
  168.     fprintf(f, "No memory blocks left allocated\n");
  169.   }
  170. }
  171. #endif
  172.  
  173. char *copyString(char *s) {
  174.   char *s1;
  175.  
  176.   s1 = gmalloc(strlen(s) + 1);
  177.   strcpy(s1, s);
  178.   return s1;
  179. }
  180.